package com.dragons.dragonsvf.controller;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.dragons.dragonsvf.dao.OrderMapper;
import com.dragons.dragonsvf.dao.UserInfoMapper;
import com.dragons.dragonsvf.entities.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

/**
 * @author Dragons.G
 * @date 2025-06-21 23:49:57
 * @description 订单控制器
 */
@RestController
public class OrderCtrl {

    @Autowired
    private OrderMapper orderMapper; // 订单Mapper

    @Autowired
    private UserInfoMapper userInfoMapper; // 用户信息Mapper

    @RequestMapping("/orderCreate") // 创建订单
    @Transactional // 防止订单创建了但是没扣款
    public ResponseDTO orderCreate(@RequestBody OrderDTO params){

        Order order = new Order();

        order.setOrder_good_id(params.getOrder_good_id());
        order.setOrder_name(params.getOrder_name());
        order.setOrder_desc(params.getOrder_desc());
        order.setOrder_price(params.getOrder_price());
        order.setOrder_sum(params.getOrder_sum());
        order.setOrder_total(params.getOrder_total());
        order.setOrder_img_url(params.getOrder_img_url());
        order.setOrder_type(params.getOrder_type());
        order.setOrder_buy_user_id(params.getOrder_buy_id());
        order.setOrder_buy_user(params.getOrder_buy_user());
        order.setOrder_buy_user_tel(params.getOrder_buy_user_tel());
        order.setOrder_other_info(params.getOrder_other_info());
        order.setOrder_command(params.getOrder_buy_command());
        order.setOrder_create_tm(new Timestamp(System.currentTimeMillis()));

        // 操作之后才会有时间
        //order.setOrder_operate_tm(new Timestamp(System.currentTimeMillis()));



        ResponseDTO res = new ResponseDTO(); // 结果返回封装

        // 先根据前台登录信息查询用户信息
        QueryWrapper<UserInfo> u = new QueryWrapper<>();
        u.eq("id", params.getOrder_buy_id())
            .eq("username", params.getOrder_buy_user())
            .eq("tel_num", params.getOrder_buy_user_tel());
        UserInfo userInfo = userInfoMapper.selectOne(u);
        // 存在此用户
        if (userInfo != null){

            // 判断用户是否被冻结
            if (userInfo.getFreeze_ornnt().equals("1")){
                res.setCode(200);
                res.setData("账户已冻结");
                res.setMsg("订单创建失败");
                return res;
            }

            // 判断用户的账户金额是否够扣除  并且用户没冻结
            else if (userInfo.getB_account() >= params.getOrder_sum()){
                userInfo.setB_account(userInfo.getB_account() - params.getOrder_sum());
                // 创建订单
                int insert = orderMapper.insert(order);
                // 更新账户余额
                int i = userInfoMapper.updateById(userInfo);

                if (insert > 0 && i > 0) {
                    res.setCode(200);
                    res.setData(params.getOrder_buy_user()+"下单成功");
                    res.setMsg("订单创建成功");
                } else {
                    res.setCode(200);
                    res.setData("下单失败");
                    res.setMsg("订单创建失败请联系管理员");
                }
            }

            // 账户余额不足
            else if (userInfo.getB_account() < params.getOrder_sum()) {
                res.setCode(200);
                res.setData("余额不足");
                res.setMsg("订单创建失败");
                return res;
            }
        } else {

        }

        return res;
    }

    @RequestMapping("/orderList") // 根据订单类型 和 用户 获取订单列表
    public ResponseDTO orderList(@RequestBody OrderDTO params){

        QueryWrapper<Order> q = new QueryWrapper<>();
        q.eq("order_type", params.getOrder_type())    // 处理类型：0待处理/1处理中/2处理完成
            .eq("order_buy_user", params.getOrder_buy_user()) // 订单下单人;
            .orderByDesc("order_create_tm"); // 按照创建时间倒序排列
        Page<Order> page = new Page<>(params.getCurrentPage(), params.getPageSize());
        Page<Order> result = orderMapper.selectPage(page, q);
        List<Order> records = result.getRecords();

        ResponseDTO res = new ResponseDTO();

        res.setCode(200);
        res.setData(records);
        res.setMsg("查询成功");

        return res;
    }

    @RequestMapping("/orderCount") // 前台根据订单类型 和 用户 获取订单总数
    public ResponseDTO orderCount(@RequestBody OrderDTO params){

        QueryWrapper<Order> q = new QueryWrapper<>();
        // 处理状态 和 下单人
        q.eq("order_type", params.getOrder_type())    // 处理类型：0待处理/1处理中/2处理完成
            .eq("order_buy_user", params.getOrder_buy_user()); // 订单下单人;

        Long aLong = orderMapper.selectCount(q);

        ResponseDTO res = new ResponseDTO();
        res.setCode(200);
        res.setData(aLong);
        res.setMsg("查询列表总数成功");
        return res;
    }

    @RequestMapping("/queryOrderById") // 根据订单ID查询订单信息
    public ResponseDTO queryOrderById(@RequestBody OrderDTO params){
        QueryWrapper<Order> q = new QueryWrapper<>();
        q.eq("id", params.getId());
        Order order = orderMapper.selectOne(q);
        ResponseDTO res = new ResponseDTO();
        res.setCode(200);
        res.setData(order);
        res.setMsg("订单信息查询成功");
        return res;
    }

    @RequestMapping("/deleteOrderById") // 删除订单
    @Transactional
    public ResponseDTO deleteOrderById(@RequestBody OrderDTO params){

        ResponseDTO res = new ResponseDTO();

        // 先根据前台登录信息查询用户信息
        QueryWrapper<UserInfo> u = new QueryWrapper<>();
        u.eq("id", params.getOrder_buy_id())
            .eq("username", params.getOrder_buy_user())
            .eq("tel_num", params.getOrder_buy_user_tel());
        UserInfo userInfo = userInfoMapper.selectOne(u);
        // 存在此用户
        if (userInfo != null){

            // 判断用户是否被冻结
            if (userInfo.getFreeze_ornnt().equals("1")){
                res.setCode(200);
                res.setData("账户已冻结");
                res.setMsg("订单创建失败");
                return res;
            }

            // 用户没冻结
            else if (userInfo.getB_account() >= params.getOrder_sum()){
                userInfo.setB_account(userInfo.getB_account() + params.getOrder_sum());
                // 删除订单
                QueryWrapper<Order> q = new QueryWrapper<>();
                q.eq("id", params.getId());
                int delete = orderMapper.delete(q);

                // 账单金额返回账户中
                int i = userInfoMapper.updateById(userInfo);

                if (delete > 0 && i > 0) {
                    res.setCode(200);
                    res.setData("订单金额已返回账户");
                    res.setMsg("订单删除成功");
                } else {
                    res.setCode(200);
                    res.setData("订单删除失败");
                    res.setMsg("订单删除失败请联系管理员");
                }
            }

        }

        return res;
    }

























    /** ---------------------------------------------------------------------- 下面是后台的订单请求*/
    @RequestMapping("/orderCreateBak") // 创建订单
    @Transactional // 防止订单创建了但是没扣款
    public ResponseDTO orderCreateBak(@RequestBody OrderBakDTO params){

        Order order = new Order();
        order.setId(UUID.randomUUID().toString().replace("-", ""));
        order.setOrder_name(params.getOrderName());
        order.setOrder_good_id(params.getOrderProductId());
        order.setOrder_desc(params.getOrderDes());
        order.setOrder_price(params.getOrderProductPrice());
        order.setOrder_sum(params.getOrderSum());
        order.setOrder_total(params.getOrderTotal());
        order.setOrder_img_url(params.getOrderProductImg());
        order.setOrder_type(params.getOrderType());
        order.setOrder_buy_user_id(params.getOrderByUser());
        order.setOrder_buy_user(params.getOrderByUserName());
        order.setOrder_buy_user_tel(params.getOrderByUserTel());
        order.setOrder_other_info(params.getOrderByUserOtherInfo());
        order.setOrder_command(params.getOrderCommand());
        order.setOrder_create_tm(new Timestamp(System.currentTimeMillis()));

        // 操作之后才会有时间
        //order.setOrder_operate_tm(new Timestamp(System.currentTimeMillis()));

        ResponseDTO res = new ResponseDTO(); // 结果返回封装

        // 先根据前台登录信息查询用户信息
        QueryWrapper<UserInfo> u = new QueryWrapper<>();
        u.eq("id", params.getOrderByUser())
            .eq("username", params.getOrderByUserName())
            .eq("tel_num", params.getOrderByUserTel());
        UserInfo userInfo = userInfoMapper.selectOne(u);
        // 存在此用户
        if (userInfo != null){

            // 判断用户是否被冻结
            if (userInfo.getFreeze_ornnt().equals("1")){
                res.setCode(200);
                res.setData("账户已冻结");
                res.setMsg("订单创建失败");
                return res;
            }

            // 判断用户的账户金额是否够扣除  并且用户没冻结
            else if (userInfo.getB_account() >= params.getOrderSum()){
                userInfo.setB_account(userInfo.getB_account() - params.getOrderSum());
                // 创建订单
                int insert = orderMapper.insert(order);
                // 更新账户余额
                int i = userInfoMapper.updateById(userInfo);

                if (insert > 0 && i > 0) {
                    res.setCode(200);
                    res.setData(params.getOrderByUserName()+"下单成功");
                    res.setMsg("订单创建成功");
                } else {
                    res.setCode(200);
                    res.setData("下单失败");
                    res.setMsg("订单创建失败请联系管理员");
                }
            }

            // 账户余额不足
            else if (userInfo.getB_account() < params.getOrderSum()) {
                res.setCode(200);
                res.setData("余额不足");
                res.setMsg("订单创建失败");
                return res;
            }
        }
        return res;
    }

    @RequestMapping("/orderUpdateBak") // 修改订单
    @Transactional
    public ResponseDTO orderUpdateBak(@RequestBody OrderBakDTO params){

        Order order = new Order();
        order.setId(params.getOrderId());
        order.setOrder_name(params.getOrderName());
        order.setOrder_good_id(params.getOrderProductId());
        order.setOrder_desc(params.getOrderDes());
        order.setOrder_price(params.getOrderProductPrice());
        order.setOrder_sum(params.getOrderSum());
        order.setOrder_total(params.getOrderTotal());
        order.setOrder_img_url(params.getOrderProductImg());
        order.setOrder_type(params.getOrderType());
        order.setOrder_buy_user_id(params.getOrderByUser());
        order.setOrder_buy_user(params.getOrderByUserName());
        order.setOrder_buy_user_tel(params.getOrderByUserTel());
        order.setOrder_other_info(params.getOrderByUserOtherInfo());
        order.setOrder_command(params.getOrderCommand());
        order.setOrder_create_tm(new Timestamp(System.currentTimeMillis()));
        // 操作之后才会有时间
        //order.setOrder_operate_tm(new Timestamp(System.currentTimeMillis()));
        ResponseDTO res = new ResponseDTO(); // 结果返回封装
        // 先根据前台登录信息查询用户信息
        QueryWrapper<UserInfo> u = new QueryWrapper<>();
        u.eq("id", params.getOrderByUser())
            .eq("username", params.getOrderByUserName())
            .eq("tel_num", params.getOrderByUserTel());
        UserInfo userInfo = userInfoMapper.selectOne(u);
        // 查询订单信息 方便下面更新 金额信息
        QueryWrapper<Order> q = new QueryWrapper<>();
        q.eq("id", params.getOrderId());
        Order hisOrder = orderMapper.selectOne(q);
        if (userInfo != null) { // 存在此用户

            if (userInfo.getFreeze_ornnt().equals("1")){ // 判断用户是否被冻结
                res.setCode(200); res.setData("账户已冻结"); res.setMsg("订单修改失败");
                return res;
            }



            /** 判断订单状态 待处理/处理中/已处理/已完成/已取消 */
            // 待处理-处理中  判断账户余额够不够  够-扣除-更新信息 不够-返回余额不足
            if (hisOrder.getOrder_type() == 0 && params.getOrderType() == 1){
                // 加上订单原始 总价 后判断 是否够 扣除订单修改的新的总价
                if ((userInfo.getB_account() + hisOrder.getOrder_sum()) >= params.getOrderSum()){
                    // 更新用户账户余额
                    userInfo.setB_account((userInfo.getB_account() + hisOrder.getOrder_sum()) - params.getOrderSum());
                    Order order1 = new Order();
                    order1 = order;
                    order1.setOrder_operate_tm(new Timestamp(System.currentTimeMillis()));
                    int updateOrder = orderMapper.updateById(order1);// 修改订单
                    int i = userInfoMapper.updateById(userInfo);// 更新账户余额
                    if (updateOrder > 0 && i > 0) {
                        res.setCode(200);
                        res.setData(params.getOrderByUserName()+"待处理-处理中-订单修改成功");
                        res.setMsg("待处理-处理中-订单修改成功");
                    } else {
                        res.setCode(200); res.setData("待处理-处理中-订单修改失败");
                        res.setMsg("待处理-处理中-订单修改失败请联系管理员");
                    }
                } else {
                    res.setCode(200); res.setData("账户余额不足");  res.setMsg("订单修改失败"); return res;
                }
            }

            // 待处理-已完成  只修改状态 不进行金额操作 也不更新信息  避免脏数据
            if (hisOrder.getOrder_type() == 0 && params.getOrderType() == 2){
                Order ord = new Order();
                ord = hisOrder;
                ord.setOrder_operate_tm(new Timestamp(System.currentTimeMillis()));
                ord.setOrder_type(2);
                int updateOrder = orderMapper.updateById(ord);// 只修改状态
                if (updateOrder > 0) {
                    res.setCode(200);
                    res.setData(params.getOrderByUserName()+"待处理-已完成-订单修改成功");
                    res.setMsg("订单已完成");
                    hisOrder.setOrder_type(0);
                } else {
                    res.setCode(200); res.setData("待处理-已完成-订单修改失败");
                    res.setMsg("待处理-已完成-订单修改失败请联系管理员");
                }
            }

            // 待处理-已取消  不修改信息只更新状态 不更新信息  退还用户订单金额
            if (hisOrder.getOrder_type() == 0 && params.getOrderType() == 3){
                Order ord1 = new Order();
                ord1 = hisOrder;
                ord1.setOrder_operate_tm(new Timestamp(System.currentTimeMillis()));
                ord1.setOrder_type(3);
                int updateOrder = orderMapper.updateById(ord1);// 只修改状态
                // 等于是删除订单 直接退还 用户金额即可
                userInfo.setB_account(userInfo.getB_account() + hisOrder.getOrder_sum());
                int i = userInfoMapper.updateById(userInfo);// 退还订单金额到账户
                if (i > 0) {
                    res.setCode(200);
                    res.setData(params.getOrderByUserName()+"待处理-已取消-订单修改成功");
                    res.setMsg("订单金额已原路退回账户");
                    hisOrder.setOrder_type(0);
                } else {
                    res.setCode(200); res.setData("待处理-已取消-订单修改失败");
                    res.setMsg("待处理-已取消-订单修改失败请联系管理员");
                }
            }







            // 处理中-待处理  判断账户余额够不够  够-扣除-更新信息 不够-返回余额不足
            if (hisOrder.getOrder_type() == 1 && params.getOrderType() == 0){
                // 加上订单原始 总价 后判断 是否够 扣除订单修改的新的总价
                if ((userInfo.getB_account() + hisOrder.getOrder_sum()) >= params.getOrderSum()){
                    // 更新用户账户余额
                    userInfo.setB_account((userInfo.getB_account() + hisOrder.getOrder_sum()) - params.getOrderSum());
                    Order order1 = new Order();
                    order1 = order;
                    order1.setOrder_operate_tm(new Timestamp(System.currentTimeMillis()));
                    int updateOrder = orderMapper.updateById(order1);// 修改订单
                    int i = userInfoMapper.updateById(userInfo);// 更新账户余额
                    if (updateOrder > 0 && i > 0) {
                        res.setCode(200);
                        res.setData(params.getOrderByUserName()+"处理中-待处理-订单修改成功");
                        res.setMsg("处理中-待处理-订单修改成功");
                    } else {
                        res.setCode(200); res.setData("处理中-待处理-订单修改失败");
                        res.setMsg("处理中-待处理-订单修改失败请联系管理员");
                    }
                } else {
                    res.setCode(200); res.setData("账户余额不足");  res.setMsg("订单修改失败"); return res;
                }
            }

            // 处理中-已完成  修改状态  不进行金额操作 也不更新信息  避免脏数据
            if (hisOrder.getOrder_type() == 1 && params.getOrderType() == 2){
                Order order1 = new Order();
                order1 = hisOrder;
                order1.setOrder_operate_tm(new Timestamp(System.currentTimeMillis()));
                order1.setOrder_type(2);
                int updateOrder = orderMapper.updateById(order1);// 只修改状态
                if (updateOrder > 0) {
                    res.setCode(200);
                    res.setData(params.getOrderByUserName()+"处理中-已完成-订单修改成功");
                    res.setMsg("处理中-已完成-订单已完成");
                    hisOrder.setOrder_type(1);
                } else {
                    res.setCode(200); res.setData("处理中-已完成-订单修改失败");
                    res.setMsg("处理中-已完成-订单修改失败请联系管理员");
                }
            }
            // 处理中-已取消  不修改信息 不更新信息  退还用户订单金额
            if (hisOrder.getOrder_type() == 1 && params.getOrderType() == 3){
                Order ord2 = new Order();
                ord2 = hisOrder;
                ord2.setOrder_operate_tm(new Timestamp(System.currentTimeMillis()));
                ord2.setOrder_type(3);
                int updateOrder = orderMapper.updateById(ord2);// 只修改状态
                userInfo.setB_account(userInfo.getB_account() + hisOrder.getOrder_sum());
                int i = userInfoMapper.updateById(userInfo);// 退还订单金额到账户
                if (updateOrder > 0 && i > 0) {
                    res.setCode(200);
                    res.setData(params.getOrderByUserName()+"处理中-已取消-订单修改成功");
                    res.setMsg("订单金额已原路退回账户");
                    hisOrder.setOrder_type(1);
                } else {
                    res.setCode(200); res.setData("处理中-已取消-订单修改失败");
                    res.setMsg("处理中-已取消-订单修改失败请联系管理员");
                }
            }








            // 状态没有变化的情况
            if (hisOrder.getOrder_type().equals(params.getOrderType())){
                // 加上订单原始 总价 后判断 是否够 扣除订单修改的新的总价
                if ((userInfo.getB_account() + hisOrder.getOrder_sum()) >= params.getOrderSum()){
                    // 更新用户账户余额
                    userInfo.setB_account((userInfo.getB_account() + hisOrder.getOrder_sum()) - params.getOrderSum());
                    Order order1 = new Order();
                    order1 = order;
                    order1.setOrder_operate_tm(new Timestamp(System.currentTimeMillis()));
                    int updateOrder = orderMapper.updateById(order1);// 修改订单
                    int i = userInfoMapper.updateById(userInfo);// 更新账户余额
                    if (updateOrder > 0 && i > 0) {
                        res.setCode(200);
                        res.setData(params.getOrderByUserName()+"订单修改成功");
                        res.setMsg("订单修改成功");
                    } else {
                        res.setCode(200); res.setData("订单修改失败");
                        res.setMsg("订单修改失败请联系管理员");
                    }
                } else {
                    res.setCode(200); res.setData("账户余额不足");  res.setMsg("订单修改失败"); return res;
                }
            }
        }
        return res;
    }

    @RequestMapping("/orderListBak") // 查询订单列表
    public ResponseDTO orderListBak(@RequestBody OrderBakDTO params){

        QueryWrapper<Order> q = new QueryWrapper<>();
        if (!"".equals(params.getOrderId().trim())) {
            q.eq("id", params.getOrderId()); // 订单号
        }
        if (!"".equals(params.getOrderByUserName().trim())) {
            q.like("order_buy_user", params.getOrderByUserName()); // 订单下单人姓名;
        }
        if (!"".equals(params.getOrderByUserTel().trim())) {
            q.like("order_buy_user_tel", params.getOrderByUserTel()); // 订单下单人电话
        }
        if (params.getOrderType()!=null) {
            q.eq("order_type",params.getOrderType()); // 订单处理类型：0待处理/1处理中/2处理完成
        }
        if (!"".equals(params.getOrderName().trim())) {
            q.like("order_name",params.getOrderName()); // 订单名称
        }
        if (!"".equals(params.getOrderProductId().trim())) {
            q.eq("order_good_id",params.getOrderProductId()); // // 订单商品ID
        }
        if (!"".equals(params.getOrderDes().trim())) {
            q.like("order_desc",params.getOrderDes()); // // 订单描述
        }
        q.orderByDesc("order_create_tm");

        Page<Order> page = new Page<>(params.getCurrentPage(), params.getPageSize());
//        Page<Order> result = orderMapper.selectPage(page, q);
        Page<Order> result = orderMapper.selectPage(page, q);
        List<Order> records = result.getRecords();

        ResponseDTO res = new ResponseDTO();

        List<OrderBakDTO> orders = new ArrayList<>();
        if (records.size() > 0) {
            for (Order record : records) {
                OrderBakDTO od = new OrderBakDTO();
                od.setOrderId(record.getId());
                od.setOrderName(record.getOrder_name());
                od.setOrderProductId(record.getOrder_good_id());
                od.setOrderDes(record.getOrder_desc());
                od.setOrderProductPrice(record.getOrder_price());
                od.setOrderSum(record.getOrder_sum());
                od.setOrderTotal(record.getOrder_total());
                od.setOrderProductImg(record.getOrder_img_url());
                od.setOrderType(record.getOrder_type());
                od.setOrderByUser(record.getOrder_buy_user_id());
                od.setOrderByUserName(record.getOrder_buy_user());
                od.setOrderByUserTel(record.getOrder_buy_user_tel());
                od.setOrderByUserOtherInfo(record.getOrder_other_info());
                od.setOrderCommand(record.getOrder_command());
                od.setOrderCreateTime(record.getOrder_create_tm());
                od.setOrderOperateTm(record.getOrder_operate_tm());

                orders.add(od);
            }
        }

        res.setCode(200);
        res.setData(orders);
        res.setMsg("查询成功");
        return res;
    }

    @RequestMapping("/orderCountBak") // 查询订单列表
    public ResponseDTO orderCountBak(@RequestBody OrderBakDTO params){

        QueryWrapper<Order> q = new QueryWrapper<>();
        if (!"".equals(params.getOrderId().trim())) {
            q.eq("id", params.getOrderId()); // 订单号
        }
        if (!"".equals(params.getOrderByUserName().trim())) {
            q.like("order_buy_user", params.getOrderByUserName()); // 订单下单人姓名;
        }
        if (!"".equals(params.getOrderByUserTel().trim())) {
            q.like("order_buy_user_tel", params.getOrderByUserTel()); // 订单下单人电话
        }
        if (params.getOrderType()!=null) {
            q.eq("order_type",params.getOrderType()); // 订单处理类型：0待处理/1处理中/2处理完成
        }
        if (!"".equals(params.getOrderName().trim())) {
            q.like("order_name",params.getOrderName()); // 订单名称
        }
        if (!"".equals(params.getOrderProductId().trim())) {
            q.eq("order_good_id",params.getOrderProductId()); // // 订单商品ID
        }
        if (!"".equals(params.getOrderDes().trim())) {
            q.like("order_desc",params.getOrderDes()); // // 订单描述
        }

        Long aLong = orderMapper.selectCount(q);

        ResponseDTO res = new ResponseDTO();
        res.setCode(200);
        res.setData(aLong);
        res.setMsg("查询列表总数成功");
        return res;
    }

    @RequestMapping("/queryOrderByIdBak") // 查询订单列表
    public ResponseDTO queryOrderByIdBak(@RequestBody OrderDTO params){
        QueryWrapper<Order> q = new QueryWrapper<>();
        q.eq("id", params.getId());
        Order order = orderMapper.selectOne(q);
        ResponseDTO res = new ResponseDTO();
        res.setCode(200);
        res.setData(order);
        res.setMsg("订单信息查询成功");
        return res;
    }

    @RequestMapping("/updateOrderType") // 更新订单状态
    public ResponseDTO updateOrderType(@RequestBody OrderBakDTO params) {

        UpdateWrapper<Order> updw = new UpdateWrapper<>();
        updw.eq("id", params.getOrderId());
        updw.set("order_type", params.getOrderType());
        // 执行更新操作  参数1为null表示不依赖实体对象
        int affectedRows = orderMapper.update(null, updw);
        // 构造响应结果
        ResponseDTO res = new ResponseDTO();
        res.setCode(200);
        if (affectedRows > 0) {
            res.setMsg("订单状态更新成功");
        } else {
            res.setMsg("订单状态更新失败");
        }
        return res;
    }

    @RequestMapping("/deleteOrderByIdBak") // 后台删除订单
    @Transactional
    public ResponseDTO deleteOrderByIdBak(@RequestBody OrderBakDTO params){

        ResponseDTO res = new ResponseDTO();

        Order order = new Order();
        order.setId(params.getOrderId());
        order.setOrder_name(params.getOrderName());
        order.setOrder_good_id(params.getOrderProductId());
        order.setOrder_desc(params.getOrderDes());
        order.setOrder_price(params.getOrderProductPrice());
        order.setOrder_sum(params.getOrderSum());
        order.setOrder_total(params.getOrderTotal());
        order.setOrder_img_url(params.getOrderProductImg());
        order.setOrder_type(params.getOrderType());
        order.setOrder_buy_user_id(params.getOrderByUser());
        order.setOrder_buy_user(params.getOrderByUserName());
        order.setOrder_buy_user_tel(params.getOrderByUserTel());
        order.setOrder_other_info(params.getOrderByUserOtherInfo());
        order.setOrder_command(params.getOrderCommand());
        order.setOrder_create_tm(new Timestamp(System.currentTimeMillis()));

        // 先根据前台登录信息查询用户信息
        QueryWrapper<UserInfo> u = new QueryWrapper<>();
        u.eq("id", params.getOrderByUser())
            .eq("username", params.getOrderByUserName())
            .eq("tel_num", params.getOrderByUserTel());
        UserInfo userInfo = userInfoMapper.selectOne(u);
        // 存在此用户
        if (userInfo != null){

            // 判断用户是否被冻结
            if (userInfo.getFreeze_ornnt().equals("1")){
                res.setCode(200);
                res.setData("账户已冻结");
                res.setMsg("订单删除失败");
                return res;
            }

            // 用户没冻结
            else {
                // 返还账户余额
                userInfo.setB_account(userInfo.getB_account() + params.getOrderSum());
                order.setOrder_type(4);
                order.setOrder_operate_tm(new Timestamp(System.currentTimeMillis()));
                int updateDelType = orderMapper.updateById(order);
                // 账单金额返回账户中
                int i = userInfoMapper.updateById(userInfo);

                if (updateDelType > 0 && i > 0) {
                    res.setCode(200);
                    res.setData("订单金额已返回账户");
                    res.setMsg("订单删除成功");
                } else {
                    res.setCode(200);
                    res.setData("订单删除失败");
                    res.setMsg("订单删除失败请联系管理员");
                }
            }

        }

        return res;
    }
}
